home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava / classsrc / java / util / bitset~1.jav < prev    next >
Encoding:
Text File  |  1995-08-11  |  4.0 KB  |  187 lines
  1. /*
  2.  * @(#)BitSet.java    1.2 95/04/20  
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.util;
  21.  
  22. /**
  23.  * A set of bits. The set is automatically grown as more bits are
  24.  * needed. 
  25.  *
  26.  * @version     1.2, 20 Apr 1995
  27.  * @author Arthur van Hoff
  28.  */
  29. public final class BitSet {
  30.     final static int BITS = 6;
  31.     final static int MASK = (1<<BITS)-1;
  32.     long bits[];
  33.  
  34.     /**
  35.      * Create an empty set.
  36.      */
  37.     public BitSet() {
  38.     this(1<<BITS);
  39.     }
  40.  
  41.     /**
  42.      * Create an empty set of a know size.
  43.      */
  44.     public BitSet(int nbits) {
  45.     bits = new long[(nbits + MASK)>>BITS];
  46.     }
  47.  
  48.     /**
  49.      * Grow the set to a larger number of bits.
  50.      */
  51.     private void grow(int nbits) {
  52.     long newbits[] = new long[Math.max(bits.length<<1, (nbits + MASK)>>BITS)];
  53.     System.arraycopy(bits, 0, newbits, 0, bits.length);
  54.     bits = newbits;
  55.     }
  56.  
  57.     /**
  58.      * Set a bit.
  59.      */
  60.     public void set(int bit) {
  61.     int n = bit>>BITS;
  62.     if (n >= bits.length) {
  63.         grow(bit);
  64.     }
  65.     bits[n] |= (1L << (bit & MASK));
  66.     }
  67.  
  68.     /**
  69.      * Clear a bit.
  70.      */
  71.     public void clear(int bit) {
  72.     int n = bit>>BITS;
  73.     if (n >= bits.length) {
  74.         grow(bit);
  75.     }
  76.     bits[n] &= ~(1L << (bit & MASK));
  77.     }
  78.  
  79.     /**
  80.      * Get a bit.
  81.      */
  82.     public boolean get(int bit) {
  83.     int n = bit>>BITS;
  84.     return (n < bits.length) ? ((bits[n] & (1L << (bit & MASK))) != 0) : false;
  85.     }
  86.  
  87.     /**
  88.      * Logical AND with another set of bits.
  89.      */
  90.     public void and(BitSet set) {
  91.     int n = Math.min(bits.length, set.bits.length);
  92.     for (int i = n ; i-- > 0 ; ) {
  93.         bits[i] &= set.bits[i];
  94.     }
  95.     for (; n < bits.length ; n++) {
  96.         bits[n] = 0;
  97.     }
  98.     }
  99.  
  100.     /**
  101.      * Logical OR with another set of bits.
  102.      */
  103.     public void or(BitSet set) {
  104.     for (int i = Math.min(bits.length, set.bits.length) ; i-- > 0 ;) {
  105.         bits[i] |= set.bits[i];
  106.     }
  107.     }
  108.  
  109.     /**
  110.      * Logical XOR with another set of bits.
  111.      */
  112.     public void xor(BitSet set) {
  113.     for (int i = Math.min(bits.length, set.bits.length) ; i-- > 0 ;) {
  114.         bits[i] ^= set.bits[i];
  115.     }
  116.     }
  117.  
  118.     /**
  119.      * Compare two bit sets.
  120.      */
  121.     public boolean equals(BitSet set) {
  122.     int n = Math.min(bits.length, set.bits.length);
  123.     for (int i = n ; i-- > 0 ;) {
  124.         if (bits[i] != set.bits[i]) {
  125.         return false;
  126.         }
  127.     }
  128.     if (bits.length > n) {
  129.         for (int i = bits.length ; i-- > n ;) {
  130.         if (bits[i] != 0) {
  131.             return false;
  132.         }
  133.         }
  134.     } else if (set.bits.length > n) {
  135.         for (int i = set.bits.length ; i-- > n ;) {
  136.         if (set.bits[i] != 0) {
  137.             return false;
  138.         }
  139.         }
  140.     }
  141.     return true;
  142.     }
  143.  
  144.     /**
  145.      * Size, returns the number of bits.
  146.      */
  147.     public int size() {
  148.     return bits.length << BITS;
  149.     }
  150.  
  151.     /**
  152.      * Compare against an object.
  153.      */
  154.     public boolean equals(Object obj) {
  155.     if ((obj != null) && (obj instanceof BitSet)) {
  156.         return equals((BitSet)obj);
  157.     }
  158.     return false;
  159.     }
  160.  
  161.     /**
  162.      * Clone
  163.      */
  164.     public Object clone() {
  165.     BitSet set = (BitSet)super.clone();
  166.     set.bits = new long[bits.length];
  167.     System.arraycopy(bits, 0, set.bits, 0, bits.length);
  168.     return set;
  169.     }
  170.  
  171.     /**
  172.      * Convert to a string.
  173.      */
  174.     public String toString() {
  175.     String str = "";
  176.     for (int i = 0 ; i < (bits.length << BITS) ; i++) {
  177.         if (get(i)) {
  178.         if (str.length() > 0) {
  179.             str += ", ";
  180.         }
  181.         str = str + i;
  182.         }
  183.     }
  184.     return "{" + str + "}";
  185.     }
  186. }
  187.